// 云对象教程: https://uniapp.dcloud.net.cn/uniCloud/cloud-obj
// jsdoc语法提示教程：https://ask.dcloud.net.cn/docs/#//ask.dcloud.net.cn/article/129
const db = uniCloud.database();
const groupsCollection = db.collection('groups');
const { verifyToken } = require('aiutils');

/**
 * 验证用户token并获取用户ID
 * @param {string} token - 用户token
 * @returns {string|null} 用户ID，如果token无效则返回null
 */
async function validateTokenAndGetUserId(token) {
	// 如果没有token，返回null
	if (!token) {
		return null;
	}
	
	try {
		// 处理Bearer token格式
		const actualToken = token.startsWith('Bearer ') ? token.slice(7) : token;
		
		// 验证token
		const verifyResult = verifyToken(actualToken);
		
		// 如果验证失败，返回null
		if (!verifyResult.valid) {
			return null;
		}
		
		// 从token中获取用户ID
		const userId = verifyResult.payload.userId;
		
		// 查询用户信息
		const userCollection = db.collection('users');
		const userResult = await userCollection.doc(userId).get();
		
		if (userResult.data.length === 0) {
			return null;
		}
		
		// 返回用户ID
		return userResult.data[0]._id;
	} catch (error) {
		// 出现任何错误，返回null
		return null;
	}
}

/**
 * 确保群组有所有必要的字段
 * @param {object} group 群组信息
 * @param {string} userId 用户ID
 * @param {boolean} isCreate 是否是创建操作
 * @returns {object} 完整的群组信息
 */
function ensureGroupFields(group, userId, isCreate = false) {
	// 基本字段
	return {
		name: isCreate ? (group.name || `群聊 ${Date.now().toString(36)}`) : group.name,
		members: group.members || [],
		createTime: group.createTime || Date.now(),
		updateTime: Date.now(),
		userId: userId // 群组创建者ID
	};
}

module.exports = {
	/**
	 * 获取所有群组（包括用户创建的和参与的群组）
	 * @param {string} token - 用户token
	 * @returns {object} 包含所有群组的数组
	 */
	async getAllGroups(token) {
		try {
			// 验证token并获取用户ID
			const userId = await validateTokenAndGetUserId(token);
			
			// 用户未登录时返回空数组
			if (!userId) {
				return {
					errCode: 'NOT_LOGGED_IN',
					errMsg: '用户未登录',
					data: []
				};
			}
			
			// 查询条件：用户创建的群组或者用户是成员的群组
			const query = {
				$or: [
					{ userId: userId },
					{ members: userId }
				]
			};
			
			// 执行查询
			const { data: groups } = await groupsCollection.where(query).get();
			
			return {
				errCode: 0,
				errMsg: '获取群组列表成功',
				data: groups
			};
		} catch (error) {
			return {
				errCode: 'GET_GROUPS_FAILED',
				errMsg: '获取群组列表失败：' + error.message,
				data: [] // 发生错误时返回空数组
			};
		}
	},
	
	/**
	 * 根据ID获取群组
	 * @param {string} token - 用户token
	 * @param {string} id - 群组ID
	 * @returns {object} 群组信息
	 */
	async getGroupById(token, id) {
		// 参数校验
		if (!id) {
			return {
				errCode: 'PARAM_IS_NULL',
				errMsg: '群组ID不能为空',
				data: null
			};
		}
		
		try {
			// 验证token并获取用户ID
			const userId = await validateTokenAndGetUserId(token);
			
			// 用户未登录时返回权限错误
			if (!userId) {
				return {
					errCode: 'NOT_LOGGED_IN',
					errMsg: '用户未登录',
					data: null
				};
			}
			
			// 查询群组
			const { data } = await groupsCollection.doc(id).get();
			
			if (data && data.length > 0) {
				const group = data[0];
				
				// 检查权限：用户是创建者或成员
				if (group.userId === userId || group.members.includes(userId)) {
					return {
						errCode: 0,
						errMsg: '获取群组成功',
						data: group
					};
				} else {
					// 无权访问，返回null
					return {
						errCode: 'PERMISSION_DENIED',
						errMsg: '无权访问该群组',
						data: null
					};
				}
			} else {
				return {
					errCode: 'GROUP_NOT_FOUND',
					errMsg: '未找到该群组',
					data: null
				};
			}
		} catch (error) {
			return {
				errCode: 'GET_GROUP_FAILED',
				errMsg: '获取群组失败：' + error.message,
				data: null
			};
		}
	},
	
	/**
	 * 创建群组
	 * @param {string} token - 用户token
	 * @param {object} group - 群组信息，包含name和members
	 * @returns {object} 创建结果
	 */
	async createGroup(token, group) {
		// 参数校验
		if (!group) {
			return {
				errCode: 'PARAM_IS_NULL',
				errMsg: '群组信息不能为空'
			};
		}
		
		try {
			// 验证token并获取用户ID
			const userId = await validateTokenAndGetUserId(token);
			
			// 用户未登录时返回权限错误
			if (!userId) {
				return {
					errCode: 'NOT_LOGGED_IN',
					errMsg: '请先登录后再创建群组'
				};
			}
			
			// 确保群组有必要的字段，并关联到当前用户 (传入isCreate=true)
			const completeGroup = ensureGroupFields(group, userId, true);
			
			// 将创建者也添加到成员列表中
			if (!completeGroup.members.includes(userId)) {
				completeGroup.members.push(userId);
			}
			
			const result = await groupsCollection.add(completeGroup);
			return {
				errCode: 0,
				errMsg: '创建群组成功',
				data: {
					id: result.id,
					...completeGroup
				}
			};
		} catch (error) {
			return {
				errCode: 'CREATE_GROUP_FAILED',
				errMsg: '创建群组失败：' + error.message
			};
		}
	},
	
	/**
	 * 更新群组
	 * @param {string} token - 用户token
	 * @param {object} group - 群组信息
	 * @returns {object} 更新结果
	 */
	async updateGroup(token, group) {
		// 参数校验
		if (!group || !group._id) {
			return {
				errCode: 'PARAM_IS_NULL',
				errMsg: '群组信息或ID不能为空'
			};
		}
		
		try {
			// 验证token并获取用户ID
			const userId = await validateTokenAndGetUserId(token);
			
			// 用户未登录时返回权限错误
			if (!userId) {
				return {
					errCode: 'NOT_LOGGED_IN',
					errMsg: '请先登录后再更新群组'
				};
			}
			
			// 先查询群组，检查权限
			const { data } = await groupsCollection.doc(group._id).get();
			
			if (!data || data.length === 0) {
				return {
					errCode: 'GROUP_NOT_FOUND',
					errMsg: '未找到该群组'
				};
			}
			
			const existingGroup = data[0];
			
			// 检查权限：只有创建者可以更新群组信息
			if (existingGroup.userId !== userId) {
				return {
					errCode: 'PERMISSION_DENIED',
					errMsg: '无权更新该群组'
				};
			}
			
			// 确保群组有必要的字段，并保持创建者ID不变 (传入isCreate=false)
			const completeGroup = ensureGroupFields(group, existingGroup.userId, false);
			const id = group._id;
			delete completeGroup._id; // 移除_id字段，避免更新时出错
			
			await groupsCollection.doc(id).update(completeGroup);
			return {
				errCode: 0,
				errMsg: '更新群组成功',
				data: {
					_id: id,
					...completeGroup
				}
			};
		} catch (error) {
			return {
				errCode: 'UPDATE_GROUP_FAILED',
				errMsg: '更新群组失败：' + error.message
			};
		}
	},
	
	/**
	 * 添加成员到群组
	 * @param {string} token - 用户token
	 * @param {string} groupId - 群组ID
	 * @param {string} memberId - 要添加的成员ID
	 * @returns {object} 添加结果
	 */
	async addMember(token, groupId, memberId) {
		// 参数校验
		if (!groupId || !memberId) {
			return {
				errCode: 'PARAM_IS_NULL',
				errMsg: '群组ID和成员ID不能为空'
			};
		}
		
		try {
			// 验证token并获取用户ID
			const userId = await validateTokenAndGetUserId(token);
			
			// 用户未登录时返回权限错误
			if (!userId) {
				return {
					errCode: 'NOT_LOGGED_IN',
					errMsg: '请先登录后再操作'
				};
			}
			
			// 先查询群组，检查权限
			const { data } = await groupsCollection.doc(groupId).get();
			
			if (!data || data.length === 0) {
				return {
					errCode: 'GROUP_NOT_FOUND',
					errMsg: '未找到该群组'
				};
			}
			
			const group = data[0];
			
			// 检查权限：只有创建者可以添加成员
			if (group.userId !== userId) {
				return {
					errCode: 'PERMISSION_DENIED',
					errMsg: '无权向该群组添加成员'
				};
			}
			
			// 检查成员是否已在群组中
			if (group.members.includes(memberId)) {
				return {
					errCode: 'MEMBER_ALREADY_EXISTS',
					errMsg: '该成员已在群组中'
				};
			}
			
			// 添加成员
			const members = [...group.members, memberId];
			await groupsCollection.doc(groupId).update({
				members,
				updateTime: Date.now()
			});
			
			return {
				errCode: 0,
				errMsg: '添加成员成功',
				data: {
					groupId,
					members
				}
			};
		} catch (error) {
			return {
				errCode: 'ADD_MEMBER_FAILED',
				errMsg: '添加成员失败：' + error.message
			};
		}
	},
	
	/**
	 * 从群组移除成员
	 * @param {string} token - 用户token
	 * @param {string} groupId - 群组ID
	 * @param {string} memberId - 要移除的成员ID
	 * @returns {object} 移除结果
	 */
	async removeMember(token, groupId, memberId) {
		// 参数校验
		if (!groupId || !memberId) {
			return {
				errCode: 'PARAM_IS_NULL',
				errMsg: '群组ID和成员ID不能为空'
			};
		}
		
		try {
			// 验证token并获取用户ID
			const userId = await validateTokenAndGetUserId(token);
			
			// 用户未登录时返回权限错误
			if (!userId) {
				return {
					errCode: 'NOT_LOGGED_IN',
					errMsg: '请先登录后再操作'
				};
			}
			
			// 先查询群组，检查权限
			const { data } = await groupsCollection.doc(groupId).get();
			
			if (!data || data.length === 0) {
				return {
					errCode: 'GROUP_NOT_FOUND',
					errMsg: '未找到该群组'
				};
			}
			
			const group = data[0];
			
			// 检查权限：创建者可以移除任何成员，成员只能移除自己
			if (group.userId !== userId && userId !== memberId) {
				return {
					errCode: 'PERMISSION_DENIED',
					errMsg: '无权从该群组移除成员'
				};
			}
			
			// 检查要移除的成员是否在群组中
			if (!group.members.includes(memberId)) {
				return {
					errCode: 'MEMBER_NOT_FOUND',
					errMsg: '该成员不在群组中'
				};
			}
			
			// 不能移除创建者
			if (memberId === group.userId) {
				return {
					errCode: 'CANNOT_REMOVE_CREATOR',
					errMsg: '不能移除群组创建者'
				};
			}
			
			// 移除成员
			const members = group.members.filter(id => id !== memberId);
			await groupsCollection.doc(groupId).update({
				members,
				updateTime: Date.now()
			});
			
			return {
				errCode: 0,
				errMsg: '移除成员成功',
				data: {
					groupId,
					members
				}
			};
		} catch (error) {
			return {
				errCode: 'REMOVE_MEMBER_FAILED',
				errMsg: '移除成员失败：' + error.message
			};
		}
	},
	
	/**
	 * 删除群组（只有创建者可以删除）
	 * @param {string} token - 用户token
	 * @param {string} id - 群组ID
	 * @returns {object} 删除结果
	 */
	async deleteGroup(token, id) {
		// 参数校验
		if (!id) {
			return {
				errCode: 'PARAM_IS_NULL',
				errMsg: '群组ID不能为空'
			};
		}
		
		try {
			// 验证token并获取用户ID
			const userId = await validateTokenAndGetUserId(token);
			
			// 用户未登录时返回权限错误
			if (!userId) {
				return {
					errCode: 'NOT_LOGGED_IN',
					errMsg: '请先登录后再删除群组'
				};
			}
			
			// 先查询群组，检查权限
			const { data } = await groupsCollection.doc(id).get();
			
			if (!data || data.length === 0) {
				return {
					errCode: 'GROUP_NOT_FOUND',
					errMsg: '未找到该群组'
				};
			}
			
			const group = data[0];
			
			// 检查权限：只有创建者可以删除群组
			if (group.userId !== userId) {
				return {
					errCode: 'PERMISSION_DENIED',
					errMsg: '无权删除该群组'
				};
			}
			
			await groupsCollection.doc(id).remove();
			return {
				errCode: 0,
				errMsg: '删除群组成功'
			};
		} catch (error) {
			return {
				errCode: 'DELETE_GROUP_FAILED',
				errMsg: '删除群组失败：' + error.message
			};
		}
	}
}
